/**
 * 安全访问Pinia store的帮助工具
 * 提供一个安全的方式来访问Pinia store，避免在组件外使用时出错
 */
import { getCurrentInstance } from 'vue'
import { useBloodSugarStore, useUserStore, useReminderStore } from '@/store/pinia.js'

// 缓存的store实例
let bloodSugarStoreCache = null;
let userStoreCache = null;
let reminderStoreCache = null;

/**
 * 从全局应用中获取Pinia实例
 * 这是一个备用方法，当组件外无法直接获取Pinia时使用
 * @returns {Object|null} Pinia实例或null
 */
function getPiniaFromGlobal() {
  try {
    if (typeof getApp !== 'undefined') {
      const app = getApp();
      // 优先尝试获取$pinia实例
      if (app && app.$pinia) {
        return app.$pinia;
      }
      // 其次尝试从globalData获取
      if (app && app.globalData && app.globalData.pinia) {
        return app.globalData.pinia;
      }
    }
    return null;
  } catch (error) {
    console.error('从全局获取Pinia失败:', error);
    return null;
  }
}

/**
 * 安全地获取BloodSugar store
 * 优先使用缓存，组件内使用标准方式，组件外使用备用方式
 * @returns {Object|null} 血糖记录store或null
 */
export function getBloodSugarStore() {
  try {
    // 如果有缓存，直接使用缓存
    if (bloodSugarStoreCache) {
      return bloodSugarStoreCache;
    }
    
    // 检查当前是否在组件环境中
    const instance = getCurrentInstance();
    if (instance) {
      // 组件内使用正常方式
      bloodSugarStoreCache = useBloodSugarStore();
      return bloodSugarStoreCache;
    } else {
      // 尝试从全局获取Pinia
      const pinia = getPiniaFromGlobal();
      if (pinia) {
        try {
          // 使用全局Pinia创建store
          bloodSugarStoreCache = useBloodSugarStore(pinia);
          return bloodSugarStoreCache;
        } catch (error) {
          console.warn('使用全局Pinia创建BloodSugarStore失败:', error);
        }
      }
      
      // 如果上述方法都失败，使用备用存储
      console.warn('在组件外访问BloodSugarStore，使用备用存储');
      return createLocalStorageBackup('bloodSugar');
    }
  } catch (error) {
    // 出错时使用备用方式
    console.error('访问BloodSugarStore出错，使用备用存储', error);
    return createLocalStorageBackup('bloodSugar');
  }
}

/**
 * 安全地获取User store
 * @returns {Object|null} 用户store或null
 */
export function getUserStore() {
  try {
    // 如果有缓存，直接使用缓存
    if (userStoreCache) {
      return userStoreCache;
    }
    
    const instance = getCurrentInstance();
    if (instance) {
      userStoreCache = useUserStore();
      return userStoreCache;
    } else {
      // 尝试从全局获取Pinia
      const pinia = getPiniaFromGlobal();
      if (pinia) {
        try {
          // 使用全局Pinia创建store
          userStoreCache = useUserStore(pinia);
          return userStoreCache;
        } catch (error) {
          console.warn('使用全局Pinia创建UserStore失败:', error);
        }
      }
      
      console.warn('在组件外访问UserStore，使用备用存储');
      return createLocalStorageBackup('user');
    }
  } catch (error) {
    console.error('访问UserStore出错，使用备用存储', error);
    return createLocalStorageBackup('user');
  }
}

/**
 * 安全地获取Reminder store
 * @returns {Object|null} 提醒store或null
 */
export function getReminderStore() {
  try {
    // 如果有缓存，直接使用缓存
    if (reminderStoreCache) {
      return reminderStoreCache;
    }
    
    const instance = getCurrentInstance();
    if (instance) {
      reminderStoreCache = useReminderStore();
      return reminderStoreCache;
    } else {
      // 尝试从全局获取Pinia
      const pinia = getPiniaFromGlobal();
      if (pinia) {
        try {
          // 使用全局Pinia创建store
          reminderStoreCache = useReminderStore(pinia);
          return reminderStoreCache;
        } catch (error) {
          console.warn('使用全局Pinia创建ReminderStore失败:', error);
        }
      }
      
      console.warn('在组件外访问ReminderStore，使用备用存储');
      return createLocalStorageBackup('reminder');
    }
  } catch (error) {
    console.error('访问ReminderStore出错，使用备用存储', error);
    return createLocalStorageBackup('reminder');
  }
}

/**
 * 创建基于本地存储的备用存储对象
 * 当Pinia不可用时，使用此函数提供基本的存储功能
 * @param {String} storeType - 存储类型: 'bloodSugar', 'user', 'reminder'
 * @returns {Object} 备用存储对象
 */
function createLocalStorageBackup(storeType) {
  // 根据类型确定存储键
  const storageKeys = {
    bloodSugar: {
      records: 'bloodSugarRecords',
      statistics: 'bloodSugarStatistics'
    },
    user: {
      token: 'token',
      userInfo: 'userInfo'
    },
    reminder: {
      reminders: 'reminders'
    }
  };
  
  const keys = storageKeys[storeType] || {};
  
  // 备用存储对象 - 从本地存储读取数据
  const backup = {
    // 状态数据
    state: {},
    
    // 简单的getter方法
    getters: {},
    
    // 通用的setter方法
    setItem(key, value) {
      this.state[key] = value;
      
      // 如果有对应的存储键，则保存到本地存储
      const storageKey = keys[key];
      if (storageKey) {
        uni.setStorageSync(storageKey, value);
      }
      
      return true;
    },
    
    // 通用的getter方法
    getItem(key) {
      // 如果状态中有数据，则直接返回
      if (this.state[key] !== undefined) {
        return this.state[key];
      }
      
      // 否则尝试从本地存储获取
      const storageKey = keys[key];
      if (storageKey) {
        const value = uni.getStorageSync(storageKey);
        if (value !== undefined) {
          this.state[key] = value;
          return value;
        }
      }
      
      return null;
    }
  };
  
  // 初始化状态数据
  Object.keys(keys).forEach(key => {
    backup.state[key] = uni.getStorageSync(keys[key]) || null;
  });
  
  // 根据存储类型添加特定方法
  if (storeType === 'bloodSugar') {
    backup.records = backup.state.records || [];
    backup.statistics = backup.state.statistics || null;
    
    // 添加与Pinia store相同的方法名，使用方式一致
    backup.setRecords = function(records) {
      this.records = records;
      this.state.records = records;
      uni.setStorageSync('bloodSugarRecords', records);
    };
    
    backup.setStatistics = function(statistics) {
      this.statistics = statistics;
      this.state.statistics = statistics;
      uni.setStorageSync('bloodSugarStatistics', statistics);
    };
  } else if (storeType === 'user') {
    backup.token = backup.state.token || '';
    backup.userInfo = backup.state.userInfo || null;
    
    backup.updateToken = function(token) {
      this.token = token;
      this.state.token = token;
      uni.setStorageSync('token', token);
    };
    
    backup.updateUserInfo = function(userInfo) {
      this.userInfo = userInfo;
      this.state.userInfo = userInfo;
      uni.setStorageSync('userInfo', userInfo);
    };
  } else if (storeType === 'reminder') {
    backup.reminders = backup.state.reminders || [];
    
    backup.updateReminders = function(reminders) {
      this.reminders = reminders;
      this.state.reminders = reminders;
      uni.setStorageSync('reminders', reminders);
    };
  }
  
  // 返回备用存储对象
  return backup;
}

/**
 * 同步本地存储数据到pinia store
 * 用于在组件挂载时将本地存储数据同步到store中
 */
export function syncStorageToStore() {
  try {
    // 血糖记录同步
    const bloodSugarStore = getBloodSugarStore();
    if (bloodSugarStore && bloodSugarStore.setRecords) {
      const records = uni.getStorageSync('bloodSugarRecords') || [];
      bloodSugarStore.setRecords(records);
    }
    
    // 统计数据同步
    if (bloodSugarStore && bloodSugarStore.setStatistics) {
      const statistics = uni.getStorageSync('bloodSugarStatistics');
      if (statistics) {
        bloodSugarStore.setStatistics(statistics);
      }
    }
    
    // 用户信息同步
    const userStore = getUserStore();
    if (userStore) {
      const token = uni.getStorageSync('token') || uni.getStorageSync('xuetang_token');
      const userInfo = uni.getStorageSync('userInfo') || uni.getStorageSync('xuetang_user_info');
      
      if (userStore.updateToken && token) {
        userStore.updateToken(token);
      }
      
      if (userStore.updateUserInfo && userInfo) {
        userStore.updateUserInfo(userInfo);
      }
    }
    
    // 提醒同步
    const reminderStore = getReminderStore();
    if (reminderStore && reminderStore.updateReminders) {
      const reminders = uni.getStorageSync('reminders') || [];
      reminderStore.updateReminders(reminders);
    }
    
    console.log('Pinia存储同步完成');
    return true;
  } catch (error) {
    console.error('同步本地存储到store失败', error);
    return false;
  }
}

export default {
  getBloodSugarStore,
  getUserStore,
  getReminderStore,
  syncStorageToStore
} 